package com.ourteam.workspace.dao;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;
import org.apache.commons.lang.StringUtils;

/**
 * Template Name : DAO查询对象 Template Version : 1 Template Last Modfiy Date : Sat Aug 19 10:06:32 CST
 * 2017 Auto Generate Date : 2018-11-30 18:42:32 Warning ! This file will be overwrite when
 * regenerate !
 */
public class WorkspaceCompilerDAOQueryBean extends BaseQueryBean {

  public WorkspaceCompilerDAOQueryBean() {
    super();
  }

  public WorkspaceCompilerDAOQueryBean(BaseQueryBean aQueryBean) {
    super(aQueryBean);
  }

  public WorkspaceCompilerDAOQueryBean(BaseQueryBean aQueryBean, Map tableReplaceMap) {
    super(aQueryBean, tableReplaceMap);
  }

  public Criteria createCriteria() {

    Criteria criteria = createCriteriaInternal();
    if (oredCriteria.size() == 0) {
      oredCriteria.add(criteria);
    }
    return criteria;
  }

  protected Criteria createCriteriaInternal() {
    return new Criteria(this);
  }

  public void addIdSelectProperty() {
    addIdSelectProperty("id");
  }

  public void addIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceCompilerDAO.Id, aAlias);
    } else {
      addSelectProperty(IWorkspaceCompilerDAO.Id, "id");
    }
  }

  public void addWorkspaceIdSelectProperty() {
    addWorkspaceIdSelectProperty("workspaceId");
  }

  public void addWorkspaceIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceCompilerDAO.WorkspaceId, aAlias);
    } else {
      addSelectProperty(IWorkspaceCompilerDAO.WorkspaceId, "workspaceId");
    }
  }

  public void addCompilerNameSelectProperty() {
    addCompilerNameSelectProperty("compilerName");
  }

  public void addCompilerNameSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceCompilerDAO.CompilerName, aAlias);
    } else {
      addSelectProperty(IWorkspaceCompilerDAO.CompilerName, "compilerName");
    }
  }

  public void addCompilerTypeSelectProperty() {
    addCompilerTypeSelectProperty("compilerType");
  }

  public void addCompilerTypeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceCompilerDAO.CompilerType, aAlias);
    } else {
      addSelectProperty(IWorkspaceCompilerDAO.CompilerType, "compilerType");
    }
  }

  public void addCompilerLogoSelectProperty() {
    addCompilerLogoSelectProperty("compilerLogo");
  }

  public void addCompilerLogoSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceCompilerDAO.CompilerLogo, aAlias);
    } else {
      addSelectProperty(IWorkspaceCompilerDAO.CompilerLogo, "compilerLogo");
    }
  }

  public void addCompileCmdSelectProperty() {
    addCompileCmdSelectProperty("compileCmd");
  }

  public void addCompileCmdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceCompilerDAO.CompileCmd, aAlias);
    } else {
      addSelectProperty(IWorkspaceCompilerDAO.CompileCmd, "compileCmd");
    }
  }

  public void addRunCmdSelectProperty() {
    addRunCmdSelectProperty("runCmd");
  }

  public void addRunCmdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceCompilerDAO.RunCmd, aAlias);
    } else {
      addSelectProperty(IWorkspaceCompilerDAO.RunCmd, "runCmd");
    }
  }

  public void addDebugCmdSelectProperty() {
    addDebugCmdSelectProperty("debugCmd");
  }

  public void addDebugCmdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceCompilerDAO.DebugCmd, aAlias);
    } else {
      addSelectProperty(IWorkspaceCompilerDAO.DebugCmd, "debugCmd");
    }
  }

  public void addCompilerLocationSelectProperty() {
    addCompilerLocationSelectProperty("compilerLocation");
  }

  public void addCompilerLocationSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceCompilerDAO.CompilerLocation, aAlias);
    } else {
      addSelectProperty(IWorkspaceCompilerDAO.CompilerLocation, "compilerLocation");
    }
  }

  public void addStatusSelectProperty() {
    addStatusSelectProperty("status");
  }

  public void addStatusSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceCompilerDAO.Status, aAlias);
    } else {
      addSelectProperty(IWorkspaceCompilerDAO.Status, "status");
    }
  }

  public void addRemarksSelectProperty() {
    addRemarksSelectProperty("remarks");
  }

  public void addRemarksSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceCompilerDAO.Remarks, aAlias);
    } else {
      addSelectProperty(IWorkspaceCompilerDAO.Remarks, "remarks");
    }
  }

  public void addDefaultCompilerSelectProperty() {
    addDefaultCompilerSelectProperty("defaultCompiler");
  }

  public void addDefaultCompilerSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceCompilerDAO.DefaultCompiler, aAlias);
    } else {
      addSelectProperty(IWorkspaceCompilerDAO.DefaultCompiler, "defaultCompiler");
    }
  }

  public void addAllSelectProperties() {

    addIdSelectProperty();

    addWorkspaceIdSelectProperty();

    addCompilerNameSelectProperty();

    addCompilerTypeSelectProperty();

    addCompilerLogoSelectProperty();

    addCompileCmdSelectProperty();

    addRunCmdSelectProperty();

    addDebugCmdSelectProperty();

    addCompilerLocationSelectProperty();

    addStatusSelectProperty();

    addRemarksSelectProperty();

    addDefaultCompilerSelectProperty();
  }

  public static class Criteria extends BaseWhereCriterion<WorkspaceCompilerDAOQueryBean> {

    protected Criteria(WorkspaceCompilerDAOQueryBean aParentObject) {
      super(aParentObject);
    }

    public Criteria andIdIsNull() {
      addCriterion(IWorkspaceCompilerDAO.Id + " is null");
      return this;
    }

    public Criteria andIdIsNotNull() {
      addCriterion(IWorkspaceCompilerDAO.Id + " is not null");
      return this;
    }

    public Criteria andIdIsNotEmpty() {
      addCriterion(
          IWorkspaceCompilerDAO.Id + " is not null AND " + IWorkspaceCompilerDAO.Id + " <> ''");
      return this;
    }

    public Criteria andIdIsEmpty() {
      addCriterion(
          "(" + IWorkspaceCompilerDAO.Id + " is null OR " + IWorkspaceCompilerDAO.Id + " = '')");
      return this;
    }

    public Criteria andIdEqualTo(long value) {
      return andIdEqualTo(Long.valueOf(value));
    }

    public Criteria andIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceCompilerDAO.Id + " = ", value, "id");
      return this;
    }

    public Criteria andIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Id);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Id + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotEqualTo(long value) {
      return andIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceCompilerDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToOrIsNull(long value) {
      return andIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceCompilerDAO.Id + " is null OR " + IWorkspaceCompilerDAO.Id + " <>",
          value,
          "id");
      return this;
    }

    public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Id);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Id + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThan(long value) {
      return andIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceCompilerDAO.Id + " >", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Id);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Id + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(long value) {
      return andIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceCompilerDAO.Id + " >=", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Id);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Id + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThan(long value) {
      return andIdLessThan(Long.valueOf(value));
    }

    public Criteria andIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceCompilerDAO.Id + " <", value, "id");
      return this;
    }

    public Criteria andIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Id);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Id + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(long value) {
      return andIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceCompilerDAO.Id + " <=", value, "id");
      return this;
    }

    public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Id);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Id + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdIn(long[] values) {
      if (values.length == 1) {
        return andIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceCompilerDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceCompilerDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andIdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceCompilerDAO.Id + " in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceCompilerDAO.Id + " not in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Id + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Id + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdBetween(long value1, long value2) {
      addCriterion(IWorkspaceCompilerDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceCompilerDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(long value1, long value2) {
      addCriterion(IWorkspaceCompilerDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceCompilerDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andWorkspaceIdIsNull() {
      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " is null");
      return this;
    }

    public Criteria andWorkspaceIdIsNotNull() {
      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " is not null");
      return this;
    }

    public Criteria andWorkspaceIdIsNotEmpty() {
      addCriterion(
          IWorkspaceCompilerDAO.WorkspaceId
              + " is not null AND "
              + IWorkspaceCompilerDAO.WorkspaceId
              + " <> ''");
      return this;
    }

    public Criteria andWorkspaceIdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceCompilerDAO.WorkspaceId
              + " is null OR "
              + IWorkspaceCompilerDAO.WorkspaceId
              + " = '')");
      return this;
    }

    public Criteria andWorkspaceIdEqualTo(long value) {
      return andWorkspaceIdEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " = ", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.WorkspaceId);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdNotEqualTo(long value) {
      return andWorkspaceIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " <>", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotEqualToOrIsNull(long value) {
      return andWorkspaceIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceCompilerDAO.WorkspaceId
              + " is null OR "
              + IWorkspaceCompilerDAO.WorkspaceId
              + " <>",
          value,
          "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.WorkspaceId);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdGreaterThan(long value) {
      return andWorkspaceIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " >", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.WorkspaceId);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(long value) {
      return andWorkspaceIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " >=", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.WorkspaceId);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdLessThan(long value) {
      return andWorkspaceIdLessThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " <", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.WorkspaceId);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(long value) {
      return andWorkspaceIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " <=", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.WorkspaceId);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " not in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andWorkspaceIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andWorkspaceIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " not in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andWorkspaceIdEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceCompilerDAO.WorkspaceId + " in", Arrays.asList(values), "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceCompilerDAO.WorkspaceId + " not in", Arrays.asList(values), "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdBetween(long value1, long value2) {
      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceCompilerDAO.WorkspaceId + " between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceCompilerDAO.WorkspaceId + " not between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceCompilerDAO.WorkspaceId + " not between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andCompilerNameIsNull() {
      addCriterion(IWorkspaceCompilerDAO.CompilerName + " is null");
      return this;
    }

    public Criteria andCompilerNameIsNotNull() {
      addCriterion(IWorkspaceCompilerDAO.CompilerName + " is not null");
      return this;
    }

    public Criteria andCompilerNameIsNotEmpty() {
      addCriterion(
          IWorkspaceCompilerDAO.CompilerName
              + " is not null AND "
              + IWorkspaceCompilerDAO.CompilerName
              + " <> ''");
      return this;
    }

    public Criteria andCompilerNameIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceCompilerDAO.CompilerName
              + " is null OR "
              + IWorkspaceCompilerDAO.CompilerName
              + " = '')");
      return this;
    }

    public Criteria andCompilerNameEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerName + " = ", value, "compilerName");
      return this;
    }

    public Criteria andCompilerNameEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerName);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerNameEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerName + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerNameNotEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerName + " <>", value, "compilerName");
      return this;
    }

    public Criteria andCompilerNameNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceCompilerDAO.CompilerName
              + " is null OR "
              + IWorkspaceCompilerDAO.CompilerName
              + " <>",
          value,
          "compilerName");
      return this;
    }

    public Criteria andCompilerNameNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerName);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerNameNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerName + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerNameGreaterThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerName + " >", value, "compilerName");
      return this;
    }

    public Criteria andCompilerNameGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerName);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerNameGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerName + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerNameGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerName + " >=", value, "compilerName");
      return this;
    }

    public Criteria andCompilerNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerName);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerNameGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerName + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerNameLessThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerName + " <", value, "compilerName");
      return this;
    }

    public Criteria andCompilerNameLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerName);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerNameLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerName + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerNameLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerName + " <=", value, "compilerName");
      return this;
    }

    public Criteria andCompilerNameLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerName);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerNameLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerName + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerNameLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceCompilerDAO.CompilerName + " like", buffer.toString(), "compilerName");
      return this;
    }

    public Criteria andCompilerNameNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceCompilerDAO.CompilerName + " not like", buffer.toString(), "compilerName");
      return this;
    }

    public Criteria andCompilerNameIn(List<String> values) {

      if (values.size() == 1) {
        return andCompilerNameEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.CompilerName + " in", values, "compilerName");
        return this;
      }
    }

    public Criteria andCompilerNameNotIn(List<String> values) {
      if (values.size() == 1) {
        return andCompilerNameNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.CompilerName + " not in", values, "compilerName");
        return this;
      }
    }

    public Criteria andCompilerNameIn(String[] values) {

      if (values.length == 1) {
        return andCompilerNameEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceCompilerDAO.CompilerName + " in", Arrays.asList(values), "compilerName");
        return this;
      }
    }

    public Criteria andCompilerNameNotIn(String[] values) {
      if (values.length == 1) {
        return andCompilerNameNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceCompilerDAO.CompilerName + " not in", Arrays.asList(values), "compilerName");
        return this;
      }
    }

    public Criteria andCompilerNameIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerName + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerNameNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerName + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerNameBetween(String value1, String value2) {
      addCriterion(IWorkspaceCompilerDAO.CompilerName + " between", value1, value2, "compilerName");
      return this;
    }

    public Criteria andCompilerNameNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceCompilerDAO.CompilerName + " not between", value1, value2, "compilerName");
      return this;
    }

    public Criteria andCompilerTypeIsNull() {
      addCriterion(IWorkspaceCompilerDAO.CompilerType + " is null");
      return this;
    }

    public Criteria andCompilerTypeIsNotNull() {
      addCriterion(IWorkspaceCompilerDAO.CompilerType + " is not null");
      return this;
    }

    public Criteria andCompilerTypeIsNotEmpty() {
      addCriterion(
          IWorkspaceCompilerDAO.CompilerType
              + " is not null AND "
              + IWorkspaceCompilerDAO.CompilerType
              + " <> ''");
      return this;
    }

    public Criteria andCompilerTypeIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceCompilerDAO.CompilerType
              + " is null OR "
              + IWorkspaceCompilerDAO.CompilerType
              + " = '')");
      return this;
    }

    public Criteria andCompilerTypeEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerType + " = ", value, "compilerType");
      return this;
    }

    public Criteria andCompilerTypeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerType);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerTypeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerType + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerTypeNotEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerType + " <>", value, "compilerType");
      return this;
    }

    public Criteria andCompilerTypeNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceCompilerDAO.CompilerType
              + " is null OR "
              + IWorkspaceCompilerDAO.CompilerType
              + " <>",
          value,
          "compilerType");
      return this;
    }

    public Criteria andCompilerTypeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerType);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerTypeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerType + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerTypeGreaterThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerType + " >", value, "compilerType");
      return this;
    }

    public Criteria andCompilerTypeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerType);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerTypeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerType + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerTypeGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerType + " >=", value, "compilerType");
      return this;
    }

    public Criteria andCompilerTypeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerType);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerTypeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerType + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerTypeLessThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerType + " <", value, "compilerType");
      return this;
    }

    public Criteria andCompilerTypeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerType);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerTypeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerType + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerTypeLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerType + " <=", value, "compilerType");
      return this;
    }

    public Criteria andCompilerTypeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerType);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerTypeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerType + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerTypeLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceCompilerDAO.CompilerType + " like", buffer.toString(), "compilerType");
      return this;
    }

    public Criteria andCompilerTypeNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceCompilerDAO.CompilerType + " not like", buffer.toString(), "compilerType");
      return this;
    }

    public Criteria andCompilerTypeIn(List<String> values) {

      if (values.size() == 1) {
        return andCompilerTypeEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.CompilerType + " in", values, "compilerType");
        return this;
      }
    }

    public Criteria andCompilerTypeNotIn(List<String> values) {
      if (values.size() == 1) {
        return andCompilerTypeNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.CompilerType + " not in", values, "compilerType");
        return this;
      }
    }

    public Criteria andCompilerTypeIn(String[] values) {

      if (values.length == 1) {
        return andCompilerTypeEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceCompilerDAO.CompilerType + " in", Arrays.asList(values), "compilerType");
        return this;
      }
    }

    public Criteria andCompilerTypeNotIn(String[] values) {
      if (values.length == 1) {
        return andCompilerTypeNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceCompilerDAO.CompilerType + " not in", Arrays.asList(values), "compilerType");
        return this;
      }
    }

    public Criteria andCompilerTypeIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerType + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerTypeNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerType + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerTypeBetween(String value1, String value2) {
      addCriterion(IWorkspaceCompilerDAO.CompilerType + " between", value1, value2, "compilerType");
      return this;
    }

    public Criteria andCompilerTypeNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceCompilerDAO.CompilerType + " not between", value1, value2, "compilerType");
      return this;
    }

    public Criteria andCompilerLogoIsNull() {
      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " is null");
      return this;
    }

    public Criteria andCompilerLogoIsNotNull() {
      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " is not null");
      return this;
    }

    public Criteria andCompilerLogoIsNotEmpty() {
      addCriterion(
          IWorkspaceCompilerDAO.CompilerLogo
              + " is not null AND "
              + IWorkspaceCompilerDAO.CompilerLogo
              + " <> ''");
      return this;
    }

    public Criteria andCompilerLogoIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceCompilerDAO.CompilerLogo
              + " is null OR "
              + IWorkspaceCompilerDAO.CompilerLogo
              + " = '')");
      return this;
    }

    public Criteria andCompilerLogoEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " = ", value, "compilerLogo");
      return this;
    }

    public Criteria andCompilerLogoEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerLogo);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerLogoEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLogoNotEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " <>", value, "compilerLogo");
      return this;
    }

    public Criteria andCompilerLogoNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceCompilerDAO.CompilerLogo
              + " is null OR "
              + IWorkspaceCompilerDAO.CompilerLogo
              + " <>",
          value,
          "compilerLogo");
      return this;
    }

    public Criteria andCompilerLogoNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerLogo);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerLogoNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLogoGreaterThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " >", value, "compilerLogo");
      return this;
    }

    public Criteria andCompilerLogoGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerLogo);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerLogoGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLogoGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " >=", value, "compilerLogo");
      return this;
    }

    public Criteria andCompilerLogoGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerLogo);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerLogoGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLogoLessThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " <", value, "compilerLogo");
      return this;
    }

    public Criteria andCompilerLogoLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerLogo);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerLogoLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLogoLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " <=", value, "compilerLogo");
      return this;
    }

    public Criteria andCompilerLogoLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerLogo);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerLogoLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLogoLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " like", buffer.toString(), "compilerLogo");
      return this;
    }

    public Criteria andCompilerLogoNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceCompilerDAO.CompilerLogo + " not like", buffer.toString(), "compilerLogo");
      return this;
    }

    public Criteria andCompilerLogoIn(List<String> values) {

      if (values.size() == 1) {
        return andCompilerLogoEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " in", values, "compilerLogo");
        return this;
      }
    }

    public Criteria andCompilerLogoNotIn(List<String> values) {
      if (values.size() == 1) {
        return andCompilerLogoNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " not in", values, "compilerLogo");
        return this;
      }
    }

    public Criteria andCompilerLogoIn(String[] values) {

      if (values.length == 1) {
        return andCompilerLogoEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceCompilerDAO.CompilerLogo + " in", Arrays.asList(values), "compilerLogo");
        return this;
      }
    }

    public Criteria andCompilerLogoNotIn(String[] values) {
      if (values.length == 1) {
        return andCompilerLogoNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceCompilerDAO.CompilerLogo + " not in", Arrays.asList(values), "compilerLogo");
        return this;
      }
    }

    public Criteria andCompilerLogoIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLogoNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLogoBetween(String value1, String value2) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLogo + " between", value1, value2, "compilerLogo");
      return this;
    }

    public Criteria andCompilerLogoNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceCompilerDAO.CompilerLogo + " not between", value1, value2, "compilerLogo");
      return this;
    }

    public Criteria andCompileCmdIsNull() {
      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " is null");
      return this;
    }

    public Criteria andCompileCmdIsNotNull() {
      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " is not null");
      return this;
    }

    public Criteria andCompileCmdIsNotEmpty() {
      addCriterion(
          IWorkspaceCompilerDAO.CompileCmd
              + " is not null AND "
              + IWorkspaceCompilerDAO.CompileCmd
              + " <> ''");
      return this;
    }

    public Criteria andCompileCmdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceCompilerDAO.CompileCmd
              + " is null OR "
              + IWorkspaceCompilerDAO.CompileCmd
              + " = '')");
      return this;
    }

    public Criteria andCompileCmdEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " = ", value, "compileCmd");
      return this;
    }

    public Criteria andCompileCmdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompileCmd);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompileCmdEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompileCmdNotEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " <>", value, "compileCmd");
      return this;
    }

    public Criteria andCompileCmdNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceCompilerDAO.CompileCmd
              + " is null OR "
              + IWorkspaceCompilerDAO.CompileCmd
              + " <>",
          value,
          "compileCmd");
      return this;
    }

    public Criteria andCompileCmdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompileCmd);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompileCmdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompileCmdGreaterThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " >", value, "compileCmd");
      return this;
    }

    public Criteria andCompileCmdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompileCmd);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompileCmdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompileCmdGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " >=", value, "compileCmd");
      return this;
    }

    public Criteria andCompileCmdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompileCmd);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompileCmdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompileCmdLessThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " <", value, "compileCmd");
      return this;
    }

    public Criteria andCompileCmdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompileCmd);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompileCmdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompileCmdLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " <=", value, "compileCmd");
      return this;
    }

    public Criteria andCompileCmdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompileCmd);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompileCmdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompileCmdLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " like", buffer.toString(), "compileCmd");
      return this;
    }

    public Criteria andCompileCmdNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " not like", buffer.toString(), "compileCmd");
      return this;
    }

    public Criteria andCompileCmdIn(List<String> values) {

      if (values.size() == 1) {
        return andCompileCmdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.CompileCmd + " in", values, "compileCmd");
        return this;
      }
    }

    public Criteria andCompileCmdNotIn(List<String> values) {
      if (values.size() == 1) {
        return andCompileCmdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.CompileCmd + " not in", values, "compileCmd");
        return this;
      }
    }

    public Criteria andCompileCmdIn(String[] values) {

      if (values.length == 1) {
        return andCompileCmdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceCompilerDAO.CompileCmd + " in", Arrays.asList(values), "compileCmd");
        return this;
      }
    }

    public Criteria andCompileCmdNotIn(String[] values) {
      if (values.length == 1) {
        return andCompileCmdNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceCompilerDAO.CompileCmd + " not in", Arrays.asList(values), "compileCmd");
        return this;
      }
    }

    public Criteria andCompileCmdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompileCmdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompileCmdBetween(String value1, String value2) {
      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " between", value1, value2, "compileCmd");
      return this;
    }

    public Criteria andCompileCmdNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceCompilerDAO.CompileCmd + " not between", value1, value2, "compileCmd");
      return this;
    }

    public Criteria andRunCmdIsNull() {
      addCriterion(IWorkspaceCompilerDAO.RunCmd + " is null");
      return this;
    }

    public Criteria andRunCmdIsNotNull() {
      addCriterion(IWorkspaceCompilerDAO.RunCmd + " is not null");
      return this;
    }

    public Criteria andRunCmdIsNotEmpty() {
      addCriterion(
          IWorkspaceCompilerDAO.RunCmd
              + " is not null AND "
              + IWorkspaceCompilerDAO.RunCmd
              + " <> ''");
      return this;
    }

    public Criteria andRunCmdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceCompilerDAO.RunCmd
              + " is null OR "
              + IWorkspaceCompilerDAO.RunCmd
              + " = '')");
      return this;
    }

    public Criteria andRunCmdEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.RunCmd + " = ", value, "runCmd");
      return this;
    }

    public Criteria andRunCmdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.RunCmd);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRunCmdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.RunCmd + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRunCmdNotEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.RunCmd + " <>", value, "runCmd");
      return this;
    }

    public Criteria andRunCmdNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceCompilerDAO.RunCmd + " is null OR " + IWorkspaceCompilerDAO.RunCmd + " <>",
          value,
          "runCmd");
      return this;
    }

    public Criteria andRunCmdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.RunCmd);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRunCmdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.RunCmd + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRunCmdGreaterThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.RunCmd + " >", value, "runCmd");
      return this;
    }

    public Criteria andRunCmdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.RunCmd);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRunCmdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.RunCmd + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRunCmdGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.RunCmd + " >=", value, "runCmd");
      return this;
    }

    public Criteria andRunCmdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.RunCmd);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRunCmdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.RunCmd + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRunCmdLessThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.RunCmd + " <", value, "runCmd");
      return this;
    }

    public Criteria andRunCmdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.RunCmd);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRunCmdLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.RunCmd + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRunCmdLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.RunCmd + " <=", value, "runCmd");
      return this;
    }

    public Criteria andRunCmdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.RunCmd);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRunCmdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.RunCmd + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRunCmdLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceCompilerDAO.RunCmd + " like", buffer.toString(), "runCmd");
      return this;
    }

    public Criteria andRunCmdNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceCompilerDAO.RunCmd + " not like", buffer.toString(), "runCmd");
      return this;
    }

    public Criteria andRunCmdIn(List<String> values) {

      if (values.size() == 1) {
        return andRunCmdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.RunCmd + " in", values, "runCmd");
        return this;
      }
    }

    public Criteria andRunCmdNotIn(List<String> values) {
      if (values.size() == 1) {
        return andRunCmdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.RunCmd + " not in", values, "runCmd");
        return this;
      }
    }

    public Criteria andRunCmdIn(String[] values) {

      if (values.length == 1) {
        return andRunCmdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceCompilerDAO.RunCmd + " in", Arrays.asList(values), "runCmd");
        return this;
      }
    }

    public Criteria andRunCmdNotIn(String[] values) {
      if (values.length == 1) {
        return andRunCmdNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceCompilerDAO.RunCmd + " not in", Arrays.asList(values), "runCmd");
        return this;
      }
    }

    public Criteria andRunCmdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.RunCmd + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRunCmdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.RunCmd + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRunCmdBetween(String value1, String value2) {
      addCriterion(IWorkspaceCompilerDAO.RunCmd + " between", value1, value2, "runCmd");
      return this;
    }

    public Criteria andRunCmdNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceCompilerDAO.RunCmd + " not between", value1, value2, "runCmd");
      return this;
    }

    public Criteria andDebugCmdIsNull() {
      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " is null");
      return this;
    }

    public Criteria andDebugCmdIsNotNull() {
      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " is not null");
      return this;
    }

    public Criteria andDebugCmdIsNotEmpty() {
      addCriterion(
          IWorkspaceCompilerDAO.DebugCmd
              + " is not null AND "
              + IWorkspaceCompilerDAO.DebugCmd
              + " <> ''");
      return this;
    }

    public Criteria andDebugCmdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceCompilerDAO.DebugCmd
              + " is null OR "
              + IWorkspaceCompilerDAO.DebugCmd
              + " = '')");
      return this;
    }

    public Criteria andDebugCmdEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " = ", value, "debugCmd");
      return this;
    }

    public Criteria andDebugCmdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.DebugCmd);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDebugCmdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andDebugCmdNotEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " <>", value, "debugCmd");
      return this;
    }

    public Criteria andDebugCmdNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceCompilerDAO.DebugCmd + " is null OR " + IWorkspaceCompilerDAO.DebugCmd + " <>",
          value,
          "debugCmd");
      return this;
    }

    public Criteria andDebugCmdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.DebugCmd);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDebugCmdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andDebugCmdGreaterThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " >", value, "debugCmd");
      return this;
    }

    public Criteria andDebugCmdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.DebugCmd);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDebugCmdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andDebugCmdGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " >=", value, "debugCmd");
      return this;
    }

    public Criteria andDebugCmdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.DebugCmd);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDebugCmdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDebugCmdLessThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " <", value, "debugCmd");
      return this;
    }

    public Criteria andDebugCmdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.DebugCmd);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDebugCmdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andDebugCmdLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " <=", value, "debugCmd");
      return this;
    }

    public Criteria andDebugCmdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.DebugCmd);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDebugCmdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDebugCmdLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " like", buffer.toString(), "debugCmd");
      return this;
    }

    public Criteria andDebugCmdNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " not like", buffer.toString(), "debugCmd");
      return this;
    }

    public Criteria andDebugCmdIn(List<String> values) {

      if (values.size() == 1) {
        return andDebugCmdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.DebugCmd + " in", values, "debugCmd");
        return this;
      }
    }

    public Criteria andDebugCmdNotIn(List<String> values) {
      if (values.size() == 1) {
        return andDebugCmdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.DebugCmd + " not in", values, "debugCmd");
        return this;
      }
    }

    public Criteria andDebugCmdIn(String[] values) {

      if (values.length == 1) {
        return andDebugCmdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceCompilerDAO.DebugCmd + " in", Arrays.asList(values), "debugCmd");
        return this;
      }
    }

    public Criteria andDebugCmdNotIn(String[] values) {
      if (values.length == 1) {
        return andDebugCmdNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceCompilerDAO.DebugCmd + " not in", Arrays.asList(values), "debugCmd");
        return this;
      }
    }

    public Criteria andDebugCmdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDebugCmdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDebugCmdBetween(String value1, String value2) {
      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " between", value1, value2, "debugCmd");
      return this;
    }

    public Criteria andDebugCmdNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceCompilerDAO.DebugCmd + " not between", value1, value2, "debugCmd");
      return this;
    }

    public Criteria andCompilerLocationIsNull() {
      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " is null");
      return this;
    }

    public Criteria andCompilerLocationIsNotNull() {
      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " is not null");
      return this;
    }

    public Criteria andCompilerLocationIsNotEmpty() {
      addCriterion(
          IWorkspaceCompilerDAO.CompilerLocation
              + " is not null AND "
              + IWorkspaceCompilerDAO.CompilerLocation
              + " <> ''");
      return this;
    }

    public Criteria andCompilerLocationIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceCompilerDAO.CompilerLocation
              + " is null OR "
              + IWorkspaceCompilerDAO.CompilerLocation
              + " = '')");
      return this;
    }

    public Criteria andCompilerLocationEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " = ", value, "compilerLocation");
      return this;
    }

    public Criteria andCompilerLocationEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerLocation);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerLocationEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLocationNotEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " <>", value, "compilerLocation");
      return this;
    }

    public Criteria andCompilerLocationNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceCompilerDAO.CompilerLocation
              + " is null OR "
              + IWorkspaceCompilerDAO.CompilerLocation
              + " <>",
          value,
          "compilerLocation");
      return this;
    }

    public Criteria andCompilerLocationNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerLocation);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerLocationNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLocationGreaterThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " >", value, "compilerLocation");
      return this;
    }

    public Criteria andCompilerLocationGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerLocation);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerLocationGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLocationGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " >=", value, "compilerLocation");
      return this;
    }

    public Criteria andCompilerLocationGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerLocation);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerLocationGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLocationLessThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " <", value, "compilerLocation");
      return this;
    }

    public Criteria andCompilerLocationLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerLocation);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerLocationLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLocationLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " <=", value, "compilerLocation");
      return this;
    }

    public Criteria andCompilerLocationLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.CompilerLocation);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCompilerLocationLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLocationLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceCompilerDAO.CompilerLocation + " like", buffer.toString(), "compilerLocation");
      return this;
    }

    public Criteria andCompilerLocationNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceCompilerDAO.CompilerLocation + " not like",
          buffer.toString(),
          "compilerLocation");
      return this;
    }

    public Criteria andCompilerLocationIn(List<String> values) {

      if (values.size() == 1) {
        return andCompilerLocationEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " in", values, "compilerLocation");
        return this;
      }
    }

    public Criteria andCompilerLocationNotIn(List<String> values) {
      if (values.size() == 1) {
        return andCompilerLocationNotEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceCompilerDAO.CompilerLocation + " not in", values, "compilerLocation");
        return this;
      }
    }

    public Criteria andCompilerLocationIn(String[] values) {

      if (values.length == 1) {
        return andCompilerLocationEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceCompilerDAO.CompilerLocation + " in",
            Arrays.asList(values),
            "compilerLocation");
        return this;
      }
    }

    public Criteria andCompilerLocationNotIn(String[] values) {
      if (values.length == 1) {
        return andCompilerLocationNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceCompilerDAO.CompilerLocation + " not in",
            Arrays.asList(values),
            "compilerLocation");
        return this;
      }
    }

    public Criteria andCompilerLocationIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLocationNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.CompilerLocation + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCompilerLocationBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceCompilerDAO.CompilerLocation + " between", value1, value2, "compilerLocation");
      return this;
    }

    public Criteria andCompilerLocationNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceCompilerDAO.CompilerLocation + " not between",
          value1,
          value2,
          "compilerLocation");
      return this;
    }

    public Criteria andStatusIsNull() {
      addCriterion(IWorkspaceCompilerDAO.Status + " is null");
      return this;
    }

    public Criteria andStatusIsNotNull() {
      addCriterion(IWorkspaceCompilerDAO.Status + " is not null");
      return this;
    }

    public Criteria andStatusIsNotEmpty() {
      addCriterion(
          IWorkspaceCompilerDAO.Status
              + " is not null AND "
              + IWorkspaceCompilerDAO.Status
              + " <> ''");
      return this;
    }

    public Criteria andStatusIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceCompilerDAO.Status
              + " is null OR "
              + IWorkspaceCompilerDAO.Status
              + " = '')");
      return this;
    }

    public Criteria andStatusEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.Status + " = ", value, "status");
      return this;
    }

    public Criteria andStatusEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Status);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Status + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.Status + " <>", value, "status");
      return this;
    }

    public Criteria andStatusNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceCompilerDAO.Status + " is null OR " + IWorkspaceCompilerDAO.Status + " <>",
          value,
          "status");
      return this;
    }

    public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Status);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Status + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.Status + " >", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Status);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Status + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.Status + " >=", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Status);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Status + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.Status + " <", value, "status");
      return this;
    }

    public Criteria andStatusLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Status);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Status + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.Status + " <=", value, "status");
      return this;
    }

    public Criteria andStatusLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Status);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Status + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceCompilerDAO.Status + " like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceCompilerDAO.Status + " not like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusIn(List<String> values) {

      if (values.size() == 1) {
        return andStatusEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.Status + " in", values, "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(List<String> values) {
      if (values.size() == 1) {
        return andStatusNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.Status + " not in", values, "status");
        return this;
      }
    }

    public Criteria andStatusIn(String[] values) {

      if (values.length == 1) {
        return andStatusEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceCompilerDAO.Status + " in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(String[] values) {
      if (values.length == 1) {
        return andStatusNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceCompilerDAO.Status + " not in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Status + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Status + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusBetween(String value1, String value2) {
      addCriterion(IWorkspaceCompilerDAO.Status + " between", value1, value2, "status");
      return this;
    }

    public Criteria andStatusNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceCompilerDAO.Status + " not between", value1, value2, "status");
      return this;
    }

    public Criteria andRemarksIsNull() {
      addCriterion(IWorkspaceCompilerDAO.Remarks + " is null");
      return this;
    }

    public Criteria andRemarksIsNotNull() {
      addCriterion(IWorkspaceCompilerDAO.Remarks + " is not null");
      return this;
    }

    public Criteria andRemarksIsNotEmpty() {
      addCriterion(
          IWorkspaceCompilerDAO.Remarks
              + " is not null AND "
              + IWorkspaceCompilerDAO.Remarks
              + " <> ''");
      return this;
    }

    public Criteria andRemarksIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceCompilerDAO.Remarks
              + " is null OR "
              + IWorkspaceCompilerDAO.Remarks
              + " = '')");
      return this;
    }

    public Criteria andRemarksEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.Remarks + " = ", value, "remarks");
      return this;
    }

    public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Remarks);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Remarks + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.Remarks + " <>", value, "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceCompilerDAO.Remarks + " is null OR " + IWorkspaceCompilerDAO.Remarks + " <>",
          value,
          "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Remarks);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Remarks + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.Remarks + " >", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Remarks);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Remarks + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.Remarks + " >=", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Remarks);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Remarks + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.Remarks + " <", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Remarks);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Remarks + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.Remarks + " <=", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.Remarks);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Remarks + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceCompilerDAO.Remarks + " like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceCompilerDAO.Remarks + " not like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksIn(List<String> values) {

      if (values.size() == 1) {
        return andRemarksEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.Remarks + " in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(List<String> values) {
      if (values.size() == 1) {
        return andRemarksNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.Remarks + " not in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(String[] values) {

      if (values.length == 1) {
        return andRemarksEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceCompilerDAO.Remarks + " in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(String[] values) {
      if (values.length == 1) {
        return andRemarksNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceCompilerDAO.Remarks + " not in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Remarks + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.Remarks + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksBetween(String value1, String value2) {
      addCriterion(IWorkspaceCompilerDAO.Remarks + " between", value1, value2, "remarks");
      return this;
    }

    public Criteria andRemarksNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceCompilerDAO.Remarks + " not between", value1, value2, "remarks");
      return this;
    }

    public Criteria andDefaultCompilerIsNull() {
      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " is null");
      return this;
    }

    public Criteria andDefaultCompilerIsNotNull() {
      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " is not null");
      return this;
    }

    public Criteria andDefaultCompilerIsNotEmpty() {
      addCriterion(
          IWorkspaceCompilerDAO.DefaultCompiler
              + " is not null AND "
              + IWorkspaceCompilerDAO.DefaultCompiler
              + " <> ''");
      return this;
    }

    public Criteria andDefaultCompilerIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceCompilerDAO.DefaultCompiler
              + " is null OR "
              + IWorkspaceCompilerDAO.DefaultCompiler
              + " = '')");
      return this;
    }

    public Criteria andDefaultCompilerEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " = ", value, "defaultCompiler");
      return this;
    }

    public Criteria andDefaultCompilerEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.DefaultCompiler);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDefaultCompilerEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultCompilerNotEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " <>", value, "defaultCompiler");
      return this;
    }

    public Criteria andDefaultCompilerNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceCompilerDAO.DefaultCompiler
              + " is null OR "
              + IWorkspaceCompilerDAO.DefaultCompiler
              + " <>",
          value,
          "defaultCompiler");
      return this;
    }

    public Criteria andDefaultCompilerNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.DefaultCompiler);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDefaultCompilerNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultCompilerGreaterThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " >", value, "defaultCompiler");
      return this;
    }

    public Criteria andDefaultCompilerGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.DefaultCompiler);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDefaultCompilerGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultCompilerGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " >=", value, "defaultCompiler");
      return this;
    }

    public Criteria andDefaultCompilerGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.DefaultCompiler);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDefaultCompilerGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultCompilerLessThan(String value) {

      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " <", value, "defaultCompiler");
      return this;
    }

    public Criteria andDefaultCompilerLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.DefaultCompiler);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDefaultCompilerLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultCompilerLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " <=", value, "defaultCompiler");
      return this;
    }

    public Criteria andDefaultCompilerLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceCompilerDAO.DefaultCompiler);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDefaultCompilerLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultCompilerLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceCompilerDAO.DefaultCompiler + " like", buffer.toString(), "defaultCompiler");
      return this;
    }

    public Criteria andDefaultCompilerNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceCompilerDAO.DefaultCompiler + " not like",
          buffer.toString(),
          "defaultCompiler");
      return this;
    }

    public Criteria andDefaultCompilerIn(List<String> values) {

      if (values.size() == 1) {
        return andDefaultCompilerEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " in", values, "defaultCompiler");
        return this;
      }
    }

    public Criteria andDefaultCompilerNotIn(List<String> values) {
      if (values.size() == 1) {
        return andDefaultCompilerNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " not in", values, "defaultCompiler");
        return this;
      }
    }

    public Criteria andDefaultCompilerIn(String[] values) {

      if (values.length == 1) {
        return andDefaultCompilerEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceCompilerDAO.DefaultCompiler + " in",
            Arrays.asList(values),
            "defaultCompiler");
        return this;
      }
    }

    public Criteria andDefaultCompilerNotIn(String[] values) {
      if (values.length == 1) {
        return andDefaultCompilerNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceCompilerDAO.DefaultCompiler + " not in",
            Arrays.asList(values),
            "defaultCompiler");
        return this;
      }
    }

    public Criteria andDefaultCompilerIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultCompilerNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceCompilerDAO.DefaultCompiler + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultCompilerBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceCompilerDAO.DefaultCompiler + " between", value1, value2, "defaultCompiler");
      return this;
    }

    public Criteria andDefaultCompilerNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceCompilerDAO.DefaultCompiler + " not between",
          value1,
          value2,
          "defaultCompiler");
      return this;
    }
  }
}
